﻿#define _CRT_SECURE_NO_WARNINGS 1
//
//
//class Person
//{
//public:
//	Person(const char* name = "", int age = 0)
//		:_name(name)
//		, _age(age)
//	{}
//
//	// 会默认生成拷贝构造+移动构造
//
//	/*Person(const Person& p)
//	:_name(p._name)
//	,_age(p._age)
//	{}*/
//
//	/*Person& operator=(const Person& p)
//	{
//	if(this != &p)
//	{
//	_name = p._name;
//	_age = p._age;
//	}
//	return *this;
//	}*/
//
//	// 不想让Person对象拷贝
//	//Person(const Person& p) = delete;
//
//	/*~Person()
//	{}*/
//
//private:
//	bit::string _name;
//	int _age;
//};
//
//int main()
//{
//	Person s1("张三", 7);
//	Person s2 = s1; // 拷贝构造
//	Person s3 = std::move(s1); // 移动构造 （没有移动构造，再调用拷贝构造）
//	//Person s4;
//	//s4 = std::move(s2);
//
//	return 0;
//}


#include<string>
#include<iostream>
using namespace std;
//namespace XmLife
//{
//	class string
//	{
//	public:
//		string(const char* str = "")
//			:_size(strlen(str))
//			, _capacity(100)
//		{
//			cout << "string() --构造" << endl;
//			_str = new char[_capacity];
//			strcpy(_str, str);
//		}
//
//		void swap(string& s)
//		{
//			::swap(_str, s._str);
//			::swap(_size, s._size);
//			::swap(_capacity, s._capacity);
//		}
//
//		// 拷贝构造
//		string(const string& s)
//			:_str(nullptr)
//		{
//			cout << "string(const string& s) -- 拷贝构造(深拷贝)" << endl;
//			_str = new char[s._capacity + 1];
//			strcpy(_str, s._str);
//			_size = s._size;
//			_capacity = s._capacity;
//		}
//
//		// 移动构造
//		string(string&& s)
//			:_str(nullptr)
//			, _size(0)
//			, _capacity(0)
//		{
//			cout << "string(string&& s) -- 资源转移" << endl;
//			swap(s); //转移资源
//		}
//
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//		}
//
//		void push_back(char ch)
//		{
//			_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';
//		}
//
//	private:
//		char* _str;
//		size_t _size;
//		size_t _capacity;
//	};
//}
//
//XmLife::string get_string()
//{
//	XmLife::string str;
//	str.push_back(1);
//	str.push_back(2);
//	str.push_back(3);
//	return str;
//}
//
//// 拷贝构造和移动构造
//int main()
//{
//	XmLife::string ret = get_string();  //移动构造
//
//	XmLife::string s1("1111111"); //构造
//	XmLife::string s2(s1); //拷贝构造
//
//	return 0;
//}


//
//class Date
//{
//public:
//	Date(int year = 1900, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	Date& operator=(const Date& d)
//	{
//		if (this != &d)
//		{
//			_year = d._year;
//			_month = d._month;
//			_day = d._day;
//		}
//
//		return *this;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};


//class Date
//{
//public:
//	Date(int year = 1900, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	int _year;
//	int _month;
//	int _day;
//};
//// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
//Date& operator=(Date& left, const Date& right)
//{
//	if (&left != &right)
//	{
//		left._year = right._year;
//		left._month = right._month;
//		left._day = right._day;
//	}
//	return left;
//}
// 编译失败：
// error C2801: “operator =”必须是非静态成员


#include<vector>
//int main()
//{
//
//	int a = 10;
//	int b = std::move(a); // b 现在拥有 a 的值
//
//	int* p = new int(10);
//	int* q = std::move(p); // q 现在拥有 p 所指向的内存
//	*p = 30;
//
//	cout << *p  <<  " ||| " << *q << endl;
//	
//	std::vector<int> vec1;
//	vec1.push_back(1);
//	std::vector<int> vec2 = std::move(vec1); // vec2 现在拥有 vec1 的所有权，vec1 是空的
//}



#include <iostream>
#include <string>

class MyClass {
private:
    std::string data;

public:
    // 构造函数
    MyClass(const std::string& value) : data(value) {
        std::cout << "构造函数，值为 " << data << std::endl;
    }

    // 移动构造函数
    MyClass(MyClass&& other) noexcept : data(std::move(other.data)) {
        std::cout << "移动构造函数，值为 " << data << std::endl;
    }

    // 移动赋值运算符
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
            std::cout << "移动赋值运算符，新值为 " << data << std::endl;
        }
        return *this;
    }

    // 析构函数
    ~MyClass() {
        std::cout << "析构函数，值为 " << data << std::endl;
    }

    // 输出值
    void print() const {
        std::cout << "值为 " << data << std::endl;
    }
};

int main() {
    MyClass obj1("Hello");
    MyClass obj2("World");

    obj1 = std::move(obj2);

    obj1.print();
    obj2.print();

    return 0;
}


class Date
{
public:
    Date* operator&()
    {
        return this;
    }
    const Date* operator&()const
    {
        return this;
    }
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
};


class Person
{
public:
    Person(const char* name = "", int age = 0)
        :_name(name)
        , _age(age)
    {}
    Person(const Person& p) = delete;
private:
    bit::string _name;
    int _age;
};
int main()
{
    Person s1;
    Person s2 = s1;
    Person s3 = std::move(s1);
    return 0;
}


#include <iostream>
#include <string.h>
using namespace std;

const int N = 1010;
int n, V, v[N], w[N];
int dp[N][N];
int main()
{
    // 读⼊数据
    cin >> n >> V;
    for (int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];

    // 解决第⼀问
    for (int i = 1; i <= n; i++)
        for (int j = 0; j <= V; j++) // 修改遍历顺序
        {
            dp[i][j] = dp[i - 1][j];
            if (j >= v[i])
                dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }

    cout << dp[n][V] << endl;


    // 解决第⼆问
    memset(dp, 0, sizeof dp);
    for (int j = 1; j <= V; j++) dp[0][j] = -1; //初始化


    for (int i = 1; i <= n; i++)
        for (int j = 0; j <= V; j++) // 修改遍历顺序
        {
            dp[i][j] = dp[i - 1][j];
            if (j >= v[i] && dp[i - 1][j - v[i]] != -1)
                dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }

    //由于最后可能凑不成体积为 V 的情况，因此返回之前需要特判⼀下。
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
    return 0;
}